home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / usenet / sources / volume91 / aplictns / quiz_1_0 / part02 / screen.c < prev   
C/C++ Source or Header  |  1991-04-10  |  18KB  |  658 lines
  1. #include <stdio.h>
  2. #include <string.h> /* strcpy */
  3. #include "screen.h"
  4.  
  5. void DrawRaisedText();
  6. void EraseQText(), EraseCText();
  7. void DrawQText(), DrawCText();
  8. void colorwindow();
  9. int OpenLibs();
  10. void InitGraphics();
  11. void UpdateMenuGraphState();
  12. void CloseGraphics();
  13. ULONG ehandlemsg();
  14. int handlegadget();
  15. int handlebuttons();
  16. int bhandlemsg();
  17. int handlemenu();
  18. void main();
  19. void redraw();
  20. void about(), abort();
  21. int load();
  22.  
  23. extern void stractivate();             /* quiz.c  */
  24.  
  25. extern void drawgraph(), cleargraph(); /* graph.c */
  26. extern int whichquestion();            /* graph.c */
  27.  
  28.  
  29. /* draw semi-3d-looking text */
  30. void DrawRaisedText(rp,text,slen,x,y)
  31.  struct RastPort *rp;
  32.   char *text;
  33.   int slen, x, y;
  34.  {
  35.     /* draw it dark */
  36.      SetAPen(rp, GREY2);
  37.      Move(rp, x+1,y);
  38.      Text(rp, text, slen);
  39.  
  40.      /* draw it light */
  41.      SetAPen(rp, GREY11);
  42.      Move(rp, x-1,y);
  43.      Text(rp, text, slen);
  44.  
  45.      /* draw it just right */
  46.      SetAPen(rp, GREY7);
  47.      Move(rp, x,y);
  48.      Text(rp, text, slen);
  49. } /* DrawRaisedText */
  50.  
  51. /* clear qtext display area */
  52. void EraseQText() {
  53.   if (qpb[0])
  54.    { /* clear area */
  55.    SetAPen(rp, GREY7);
  56.    SetDrMd(rp, JAM1);
  57.    RectFill(rp, qpt[2], qpt[3], qpb[2], qpb[3]);
  58.    qpb[0] = 0;
  59.    } /* if */
  60. } /* EraseQText */
  61.  
  62. #define QCOLOR GREY3
  63. /* draw the question */
  64. void DrawQText() 
  65. {
  66.   int slen,theight,textsize;
  67.  
  68.   /* delete old border */
  69.   if (qpb[0]) /* don't delete if first time */
  70.     {
  71.     /* clear the area */
  72.     SetAPen(rp, GREY7);
  73.     SetDrMd(rp, JAM1);
  74.     RectFill(rp, qpt[2], qpt[3], qpb[2], qpb[3]);
  75.     } /* if */
  76.   slen = strlen(qtext);
  77.   if (slen==0) return;
  78.   theight = rp->TxHeight;
  79.   textsize = slen * rp->TxWidth + 1; /* 1 pixel pad? */
  80.   qpt[0] = QX-BORDWIDTH*2;
  81.   qpt[1] = QY+theight+BORDWIDTH*2;
  82.   qpt[2] = QX-BORDWIDTH*2;
  83.   qpt[3] = QY-BORDWIDTH*2;
  84.   qpt[4] = QX+textsize+BORDWIDTH*2;
  85.   qpt[5] = QY-BORDWIDTH*2;
  86.  
  87.   qpb[0] = QX-BORDWIDTH*2;
  88.   qpb[1] = QY+theight+BORDWIDTH*2;
  89.   qpb[2] = QX+textsize+BORDWIDTH*2;
  90.   qpb[3] = QY+theight+BORDWIDTH*2;
  91.   qpb[4] = QX+textsize+BORDWIDTH*2;
  92.   qpb[5] = QY-BORDWIDTH*2;
  93.  
  94.   if (slen <= maxqchars) {
  95.      /* set border */
  96.      DrawBorder(rp,&qtop,0,0);
  97.      /* draw black box */
  98.      SetAPen(rp, QCOLOR);
  99.      SetDrMd(rp, JAM1);
  100.      RectFill(rp, qpt[2]+BORDWIDTH, qpt[3]+BORDWIDTH,
  101.                   qpb[2]-BORDWIDTH, qpb[3]-BORDWIDTH);
  102.      /* now draw text */
  103.      DrawRaisedText(rp, qtext, slen, QX, QY+baseheight);
  104.      } /* if */
  105.   else { /* must make bigger window */
  106.      char *lastspace = NULL, *s, *r;
  107.      int done = 0, numlines = 0, maxlen = 0, i;
  108.      /* Have to copy strings and output them after breaking up */
  109.      /* qtext.  We must know maxlen's value in order to draw   */
  110.      /* the dark grey rectangle                                */
  111.      char brokentext[MAXLINES][MAXQCHARS];
  112.      int sizes[MAXLINES];
  113.      r = qtext;
  114.  
  115.      do {
  116.        numlines++;
  117.        s = r;
  118.        while (s<r+maxqchars) {
  119.         if (*s == ' ') lastspace = s;
  120.         else if (*s == '\0') {done = 1; break;}
  121.         s++;
  122.         } /* while */
  123.       /* this is gross */
  124.       /* we found a line */
  125.       if (lastspace) {
  126.         if (!done) *lastspace = '\0'; /* gulp */
  127.         slen = strlen(r); if (slen>maxlen) maxlen = slen;
  128.         strncpy(brokentext[numlines-1],r,slen);
  129.         sizes[numlines-1] = slen;
  130.         /*DrawRaisedText(rp, r, slen, QX, QY+baseheight+theight*(numlines-1));*/
  131.         if (!done) *lastspace = ' ';
  132.         r = lastspace + 1;
  133.         while (*r == ' ') r++; /* skip over any more spaces */
  134.         if (!*r) done = 1;
  135.         lastspace = NULL;
  136.         } /* if lastspace */
  137.       else if (done) /* reached the end in this iteration */
  138.        {
  139.         slen = strlen(r); if (slen>maxlen) maxlen = slen;
  140.         strncpy(brokentext[numlines-1],r,slen);
  141.         sizes[numlines-1] = slen;
  142.         /*DrawRaisedText(rp, r, slen, QX, QY+baseheight+theight*(numlines-1));*/
  143.        }
  144.       else { /* no breaks */
  145.         strncpy(brokentext[numlines-1],r,maxqchars);
  146.         sizes[numlines-1] = maxqchars;
  147.         /*DrawRaisedText(rp, r, maxqchars, QX, QY+baseheight+theight*(numlines-1));*/
  148.         r+=maxqchars; maxlen = maxqchars;
  149.         while (*r == ' ') r++; /* skip over any more spaces */
  150.         if (!*r) done = 1;
  151.         } /* else */
  152.     } while ((!done)&&(numlines<MAXLINES));
  153.      /* set border -- only 3 must be changed*/
  154.      textsize = maxlen * rp->TxWidth + 1; /* 1 pixel pad? */
  155.  
  156.      qpt[4] = QX+textsize+BORDWIDTH;
  157.      qpb[2] = QX+textsize+BORDWIDTH;
  158.      qpb[4] = QX+textsize+BORDWIDTH;
  159.  
  160.      qpt[1] = QY+theight*numlines+BORDWIDTH;
  161.      qpb[1] = QY+theight*numlines+BORDWIDTH;
  162.      qpb[3] = QY+theight*numlines+BORDWIDTH;
  163.  
  164.      DrawBorder(rp,&qtop,0,0);
  165.      /* draw black box */
  166.      SetAPen(rp, QCOLOR);
  167.      SetDrMd(rp, JAM1);
  168.      RectFill(rp, qpt[2]+BORDWIDTH, qpt[3]+BORDWIDTH,
  169.                   qpb[2]-BORDWIDTH, qpb[3]-BORDWIDTH);
  170.  
  171.     /* now actually draw the text */
  172.     for (i=0;i<numlines;i++)
  173.      DrawRaisedText(rp, brokentext[i], sizes[i], QX, QY+baseheight+theight*i);
  174.   } /* else */
  175. } /* DrawQText */
  176.  
  177. /* clear ctext display area */
  178. void EraseCText() {
  179.   if (cpb[0])
  180.    { /* clear area */
  181.    SetAPen(rp, GREY7);
  182.    SetDrMd(rp, JAM1);
  183.    RectFill(rp, cpt[2], cpt[3], cpb[2], cpb[3]);
  184.    cpb[0] = 0;
  185.    } /* if */
  186. } /* EraseCText */
  187.  
  188. #define CCOLOR 15 /* ? */
  189. /* draw the correct answer */
  190. void DrawCText()
  191. {
  192.   int slen, theight, textsize;
  193.   /* delete old border if existing */
  194.   if (cpb[0])
  195.    { /* clear area */
  196.    SetAPen(rp, GREY7);
  197.    SetDrMd(rp, JAM1);
  198.    RectFill(rp, cpt[2], cpt[3], cpb[2], cpb[3]);
  199.    } /* if */
  200.   if (ctext==NULL) return;
  201.   slen = strlen(ctext);
  202.   if (slen==0) return;
  203.   theight = rp->TxHeight;
  204.   textsize = slen * rp->TxWidth + 1; /* 1 pixel pad? */
  205.  
  206.   cpt[0] = CX-BORDWIDTH*2;
  207.   cpt[1] = CY+theight+BORDWIDTH*2;
  208.   cpt[2] = CX-BORDWIDTH*2;
  209.   cpt[3] = CY-BORDWIDTH*2;
  210.   cpt[4] = CX+textsize+BORDWIDTH*2;
  211.   cpt[5] = CY-BORDWIDTH*2;
  212.  
  213.   cpb[0] = CX-BORDWIDTH*2;
  214.   cpb[1] = CY+theight+BORDWIDTH*2;
  215.   cpb[2] = CX+textsize+BORDWIDTH*2;
  216.   cpb[3] = CY+theight+BORDWIDTH*2;
  217.   cpb[4] = CX+textsize+BORDWIDTH*2;
  218.   cpb[5] = CY-BORDWIDTH*2;
  219.  
  220.   if (slen <= maxqchars) {
  221.      /* set border */
  222.      DrawBorder(rp,&ctop,0,0);
  223.      /* draw black box */
  224.      SetAPen(rp, CCOLOR);
  225.      SetDrMd(rp, JAM1);
  226.      RectFill(rp, cpt[2]+BORDWIDTH, cpt[3]+BORDWIDTH,
  227.                   cpb[2]-BORDWIDTH, cpb[3]-BORDWIDTH);
  228.      /* now draw text */
  229.      DrawRaisedText(rp, ctext, slen, CX, CY+baseheight);
  230.      } /* if */
  231.     else { /* must make bigger window */
  232.      char *lastspace = NULL, *s, *r;
  233.      int done = 0, numlines = 0, maxlen = 0, i;
  234.      /* Have to copy strings and output them after breaking up */
  235.      /* ctext.  We must know maxlen's value in order to draw   */
  236.      /* the dark grey rectangle                                */
  237.      char brokentext[MAXLINES][MAXQCHARS];
  238.      int sizes[MAXLINES];
  239.      r = ctext;
  240.  
  241.      do {
  242.        numlines++;
  243.        s = r;
  244.        while (s<r+maxqchars) {
  245.         if (*s == ' ') lastspace = s;
  246.         else if (*s == '\0') {done = 1; break;}
  247.         s++;
  248.         } /* while */
  249.       /* this is gross */
  250.       /* we found a line */
  251.       if (lastspace) {
  252.         if (!done) *lastspace = '\0'; /* gulp */
  253.         slen = strlen(r); if (slen>maxlen) maxlen = slen;
  254.         strncpy(brokentext[numlines-1],r,slen);
  255.         sizes[numlines-1] = slen;
  256.         if (!done) *lastspace = ' ';
  257.         r = lastspace + 1;
  258.         while (*r == ' ') r++; /* skip over any more spaces */
  259.         if (!*r) done = 1;
  260.         lastspace = NULL;
  261.         } /* if lastspace */
  262.       else if (done) /* reached the end in this iteration */
  263.        {
  264.         slen = strlen(r); if (slen>maxlen) maxlen = slen;
  265.         strncpy(brokentext[numlines-1],r,slen);
  266.         sizes[numlines-1] = slen;
  267.        }
  268.       else { /* no breaks */
  269.         strncpy(brokentext[numlines-1],r,maxqchars);
  270.         sizes[numlines-1] = maxqchars;
  271.         r+=maxqchars; maxlen = maxqchars;
  272.         while (*r == ' ') r++; /* skip over any more spaces */
  273.         if (!*r) done = 1;
  274.         } /* else */
  275.     } while ((!done)&&(numlines<MAXLINES));
  276.      /* set border -- only 3 must be changed*/
  277.      textsize = maxlen * rp->TxWidth + 1; /* 1 pixel pad? */
  278.  
  279.      cpt[4] = CX+textsize+BORDWIDTH;
  280.      cpb[2] = CX+textsize+BORDWIDTH;
  281.      cpb[4] = CX+textsize+BORDWIDTH;
  282.  
  283.      cpt[1] = CY+theight*numlines+BORDWIDTH;
  284.      cpb[1] = CY+theight*numlines+BORDWIDTH;
  285.      cpb[3] = CY+theight*numlines+BORDWIDTH;
  286.  
  287.      DrawBorder(rp,&ctop,0,0);
  288.      /* draw black box */
  289.      SetAPen(rp, CCOLOR);
  290.      SetDrMd(rp, JAM1);
  291.      RectFill(rp, cpt[2]+BORDWIDTH, cpt[3]+BORDWIDTH,
  292.                   cpb[2]-BORDWIDTH, cpb[3]-BORDWIDTH);
  293.  
  294.     /* now actually draw the text */
  295.     for (i=0;i<numlines;i++)
  296.      DrawRaisedText(rp, brokentext[i], sizes[i], CX, CY+baseheight+theight*i);
  297.   } /* else */
  298. } /* DrawCText */
  299.  
  300. /* fills in an entire window with color c */
  301. void colorwindow(w,c)
  302.   struct Window *w;
  303.   int c;
  304. {
  305.   SetDrMd(w->RPort, JAM1);
  306.   SetAPen(w->RPort, c);
  307.   RectFill(w->RPort, 0, 0, w->Width, w->Height);
  308. } /* colorwindow*/
  309.  
  310. #if 0
  311. void FatalError(s) char *s;
  312. {
  313.  printf("%s", s);
  314.  CloseGraphics();
  315.  exit(1);
  316. } /* FatalError */
  317. #endif
  318.  
  319. /* Just opens intuition library.  Returns 1 if successful, 0 if not */
  320. int iopen=0, gopen=0;
  321. int OpenLibs() {    
  322.   IntuitionBase = (struct IntuitionBase *)
  323.     OpenLibrary("intuition.library", 0);
  324.   if (IntuitionBase==NULL) return(0);
  325.   iopen = 1;
  326.   GfxBase = (struct GfxBase *)
  327.     OpenLibrary("graphics.library", 0);
  328.   if (GfxBase==NULL) return(0);
  329.   gopen=1;
  330.   return(1);
  331.   } /* OpenLibs */
  332.  
  333. void InitGraphics() {
  334.  if (OpenLibs()==0) FatalError("Couldn't open libraries!\n");
  335.  
  336.  if ((qscreen = OpenScreen(&ns)) == NULL)
  337.    FatalError("Couldn't open screen!\n");
  338.  vp = &(qscreen->ViewPort);
  339.  
  340.  /* initialize colortable */
  341.  LoadRGB4(vp, &mycmap[0], 32);
  342.  
  343. /* errnw.Screen  = qscreen;*/
  344.  backnw.Screen = qscreen;
  345.  
  346.  backnw.FirstGadget = &sgadget;
  347.  if ((backwindow = OpenWindow(&backnw)) == NULL)
  348.    FatalError("Couldn't open backdrop window!\n");
  349. /* if ((ewindow = OpenWindow(&errnw)) == NULL)
  350.    FatalError("Couldn't open error window!\n");*/
  351.  
  352.  menustrip[0] = &m1;
  353.  menustrip[1] = &m2;
  354.  menustrip[0]->NextMenu = menustrip[1];
  355.  SetMenuStrip(backwindow,menustrip[0]);
  356.   
  357.  if (qstate.Asking || (!qstate.File[0]))
  358.    OffMenu(backwindow, BEGINMENUNUM);
  359.  if (qstate.GraphType==BYTRIAL) {
  360.    OffMenu(backwindow, TRIALMENUNUM);
  361.    OnMenu(backwindow, QUESTMENUNUM);
  362.    } /* if */
  363.  else if (qstate.GraphType==BYQUESTION) 
  364.  {
  365.    OffMenu(backwindow, QUESTMENUNUM);
  366.    OnMenu(backwindow, TRIALMENUNUM);
  367.    } /* if */
  368.  ShowTitle(qscreen, FALSE);
  369.  rp = backwindow->RPort;
  370.  
  371.  /* calculate how many characters can fit in one line of text */
  372.  /* note that this method doesn't account for variable-width fonts :-( */
  373.  maxqchars = (MAXQX-QX)/rp->TxWidth;
  374.  baseheight = rp->TxBaseline;
  375.  } /* InitGraphics */
  376.  
  377. /* This is not very clean, but we need to be able to turn off/on the
  378.    correct menu items depending of the state of the graph */
  379. void UpdateMenuGraphState() {
  380.  if (qstate.GraphType==BYTRIAL) {
  381.    OffMenu(backwindow, TRIALMENUNUM);
  382.    OnMenu(backwindow, QUESTMENUNUM);
  383.  } /* if */
  384.  else if (qstate.GraphType == BYQUESTION) {
  385.    OffMenu(backwindow, QUESTMENUNUM);
  386.    OnMenu(backwindow, TRIALMENUNUM);
  387.  } /* if */
  388. } /* UpdateMenuGraphState */
  389.  
  390. void CloseGraphics()
  391. {
  392.   if (backwindow) {
  393.     ClearMenuStrip(backwindow);
  394.     while (mes = GetMsg(backwindow->UserPort)) ReplyMsg(mes);
  395.     CloseWindow(backwindow);
  396.   } /* if backwindow */
  397.   if (qscreen) CloseScreen(qscreen);
  398.   if (gopen) CloseLibrary(GfxBase);
  399.   if (iopen) CloseLibrary(IntuitionBase);
  400.   /*OpenWorkBench();*/
  401.   /*WBenchToFront();*/
  402. } /* CloseGraphics */
  403.  
  404. ULONG ehandlemsg(message)
  405.    struct IntuiMessage *message;
  406. {
  407.   struct IntuiMessage localms;
  408.   int i;
  409.   UBYTE *s, *d;
  410.   ULONG class,code;
  411.  
  412.   s = (UBYTE *)message;
  413.   d = (UBYTE *)&localms;
  414.  
  415.   for (i=0;i<sizeof(struct IntuiMessage);i++) *d++=*s++;
  416.   ReplyMsg(message);
  417.     
  418.   class = localms.Class;
  419.   code = localms.Code;
  420.   switch (class)
  421.    {
  422.      case CLOSEWINDOW:
  423.         break;
  424.      case REFRESHWINDOW:
  425.      case NEWSIZE:
  426.        redraw();
  427.      default:
  428.        break;
  429.    } /* switch */
  430.    return(class);
  431. } /* ehandlemsg */
  432.  
  433. int handlegadget(g)
  434.    struct Gadget *g;
  435. {
  436.   switch (g->GadgetID) {
  437.     case STRINGID:
  438.       atext = ((struct StringInfo *)(g->SpecialInfo))->Buffer;
  439.       /*DrawQText();*/
  440.       return(NEWSTRING);
  441.       break;
  442.     case IMAGEID:
  443.       break;
  444.     default:
  445.       break;
  446.     }
  447.      return(IGNORE);
  448.  
  449. } /* handle gadget */
  450.  
  451. void about() { printf("Quiz by Curtis Eubanks\n"); }
  452.  
  453. /* returns 1 if successful, 0 if not */
  454. int load() { 
  455.   if (*sStringInfo.Buffer)
  456.   {
  457.     strcpy(qstate.File, sStringInfo.Buffer);
  458.     history = hindices = (short *)NULL;
  459.     CleanUp(FREEALL_MSG);
  460.     if (readfile(qstate.File, &buf)) {
  461.       qstate.Asking = 1;
  462.       return 1;
  463.       } /* if */
  464.   } /* if */
  465.   return 0;
  466. } /* load */
  467.  
  468. void abort() {
  469.  } /* abort */
  470. int handlemenu(code)
  471.   ULONG code;
  472. {
  473.   ULONG MenuNumber = MENUNUM(code), ItemNumber = ITEMNUM(code);
  474.   if ((code != MENUNULL) && (ItemNumber != NOITEM)) {
  475.    if (MenuNumber == PROJMENU) {
  476.      switch (ItemNumber)
  477.        {
  478.          case QUITNUM:
  479.             return(QUITNOW);
  480.             break;
  481.          case ABOUTNUM:
  482.             about();
  483.             break;
  484.          case LOADNUM:
  485.             if (load()) return(OPENNEWFILE); else return(IGNORE);
  486.             break;
  487.          case BEGINNUM:
  488.             return(STARTASKING);
  489.             break;
  490.          default:
  491.             NonFatalError("Unknown Project Menu selection!\n");
  492.             break;
  493.          } /* switch */
  494.     } /* if project menu */
  495.   else if (MenuNumber==OPTMENU) {
  496.    switch (ItemNumber)
  497.      {
  498.        case SWITCHNUM:
  499.          return(SWITCHEM);
  500.          break;
  501.        case IGNORENUM:
  502.          qstate.CaseSensitive = !qstate.CaseSensitive;
  503.          break;
  504.        case ABORTNUM:
  505.          abort();
  506.          return(ABORTNOW);
  507.          break;
  508.        case MENUBYTRIAL:
  509.          if (qstate.GraphType != BYTRIAL && qstate.GraphType) {
  510.             qstate.GraphType = BYTRIAL;
  511.             OffMenu(backwindow, TRIALMENUNUM);
  512.             OnMenu(backwindow, QUESTMENUNUM);
  513.             cleargraph();
  514.             drawgraph();
  515.             stractivate();
  516.             }
  517.          return IGNORE;
  518.          break;
  519.        case MENUBYQUESTION:
  520.          if (qstate.GraphType != BYQUESTION && qstate.GraphType) {
  521.             qstate.GraphType = BYQUESTION;
  522.             OffMenu(backwindow, QUESTMENUNUM);
  523.             OnMenu(backwindow, TRIALMENUNUM);
  524.             cleargraph();
  525.             drawgraph();
  526.             stractivate();
  527.             }
  528.          return IGNORE;
  529.          break;
  530.        default:
  531.          NonFatalError("Unknown Option Menu selection!\n");
  532.          break;
  533.      } /* switch itemnumber */
  534.     } /* if option menu */
  535.   } /* if non-null menu selection */
  536.  return(IGNORE);
  537. } /* handlemenu */
  538.  
  539. /* handle button presses */
  540. int handlebuttons(code, mousex, mousey)
  541.   ULONG code;
  542.   SHORT mousex, mousey;
  543. {
  544.   if (code == SELECTDOWN) {
  545.     int q;
  546. #ifdef DEBUG
  547.     printf("mouse at %d, %d\n", mousex, mousey);
  548. #endif
  549.     if ((qstate.GraphType == BYQUESTION) &&
  550.         ((q=whichquestion(mousex, mousey))!=-1))
  551.        { /* in graph.c */
  552.          newquestion = q; /* global, yucky */
  553.          return DISPLAYQ;
  554.        } /* if q != -1 */
  555.     } /* if code */
  556.   return IGNORE;
  557. } /* handlebuttons */
  558.  
  559.  
  560.  
  561. int bhandlemsg(message)
  562.    struct IntuiMessage *message;
  563. {
  564.   struct IntuiMessage localms;
  565.   int i;
  566.   UBYTE *s, *d;
  567.   ULONG class,code;
  568.  
  569.   s = (UBYTE *)message;
  570.   bloop:
  571.   d = (UBYTE *)&localms;
  572.  
  573.   /* copy message */
  574.   for (i=0;i<sizeof(struct IntuiMessage);i++) *d++=*s++;
  575.   ReplyMsg(message);
  576.   
  577.   class = localms.Class;
  578.   code = localms.Code;
  579.   switch (class)
  580.    {
  581.      case REFRESHWINDOW: /* ugh.  this hurts */
  582.         /* any more REFRESHWINDOW msgs waiting? */
  583.         if (mes = GetMsg(backwindow->UserPort))
  584.         {  /* don't redraw if more than one REFRESHWINDOW in a row */
  585. /*          printf("waiting: %d ",mes->Class);
  586.             if (mes->Class==REFRESHWINDOW) printf("(refresh)\n");
  587.             else printf("(not refresh)\n");*/
  588.             s = (UBYTE *)mes; message = mes; /* legal? */
  589.             if (mes->Class==REFRESHWINDOW) goto bloop;
  590.             else { /* some other message.  Redraw and process it */
  591.                    redraw();
  592.                    goto bloop;
  593.                  } /* else */
  594.         } /* if */
  595.         else redraw();
  596.         break;
  597.      case GADGETUP:
  598.         return(handlegadget((struct Gadget *)localms.IAddress));
  599.         break;
  600.      case MENUPICK:
  601.         return(handlemenu(code));
  602.         break;
  603.      case MOUSEBUTTONS:
  604.         return(handlebuttons(code, localms.MouseX, localms.MouseY));
  605.     break;
  606.      default:
  607.         break;
  608.    } /* switch */
  609.    return(IGNORE);
  610. } /* bhandlemsg */
  611.  
  612. #if 0
  613. void main(argc, argv) 
  614.    int argc;
  615.    union {
  616.            char **args;
  617.            struct WBStartup *msg; 
  618.          } argv;
  619. {
  620.   ULONG val=0;
  621.   if (argc>2) {
  622. /*    errnw.DetailPen = atoi(argv.args[1]);
  623.     errnw.BlockPen = atoi(argv.args[2]);*/
  624.   }
  625.   if (argc>4) {
  626.     ns.DetailPen = atoi(argv.args[3]);
  627.     ns.BlockPen = atoi(argv.args[4]);
  628.   }
  629.  
  630.   InitGraphics();
  631.  
  632.   redraw();
  633.    /* WaitPort(ewindow->UserPort);*/
  634.   while(1) {
  635.    while (mes = GetMsg(backwindow->UserPort)) val=bhandlemsg(mes);
  636.    if (val == QUITNUM) break;
  637. /*   while (mes = GetMsg(ewindow->UserPort)) val=ehandlemsg(mes);*/
  638.    if (val == CLOSEWINDOW) break;
  639.    }
  640.   CloseGraphics();
  641. } /* main */
  642. #endif
  643. #define BaseX 30
  644. #define BaseY 40
  645. #define Bsize 12
  646.  
  647. void redraw() {
  648.    colorwindow(backwindow, GREY7);
  649.    SetDrMd(rp, JAM1);
  650.  
  651.    /* draw gadget's border */
  652.    DrawBorder(rp,&ibt,0,0); 
  653.    if (qtext) DrawQText();
  654.    if (qstate.ShowingAns) DrawCText();
  655.    if (qstate.GraphType) drawgraph();
  656.    RefreshGadgets(&sgadget, backwindow, NULL);
  657.  } /* redraw */
  658.